home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / program / swags_z.zip / SCREEN.SWG / 0063_3 Fast Write Routines.pas < prev    next >
Pascal/Delphi Source File  |  1994-02-18  |  5KB  |  141 lines
  1. {
  2. From: ALEX CHALFIN
  3. Subj: fast write
  4. }
  5.  
  6. Procedure FastWrite(WX, WY : Integer; Var s); Assembler;
  7.  
  8. Asm
  9.   PUSH  DS
  10.   MOV   AX,$B800
  11.   MOV   ES,AX
  12.   XOR   DI,DI
  13.   LDS   SI,s
  14.   { CALL WhereY }
  15.   MOV  AX,WY
  16.   DEC  AX
  17.   MOV  DX,160
  18.   IMUL DX
  19.   PUSH AX
  20.   XOR  CX,CX
  21.   {CALL WhereY }
  22.   MOV   AX,WY
  23.   MOV   BX,AX
  24.   POP    AX
  25.   DEC   BX
  26.   SHL   BX,1
  27.   ADD   AX,BX
  28.   MOV   DI,AX
  29.   XOR   AX,AX
  30.   LODSB
  31.   MOV   CX,AX
  32.   MOV   AH,TextAttr
  33.  @Top:
  34.   LODSB
  35.   STOSW
  36.   LOOP @Top
  37.   POP  DS
  38. End;
  39.  
  40. {
  41. From: BOB SWART
  42. Subj: fast write
  43. }
  44.  
  45.  procedure FastWrite(Col,Row,Attr: Byte; Str: String); Assembler;
  46.  ASM
  47.        push  DS                    { Save DS                            }
  48.        mov   CH,Row                { CH = Row                           }
  49.        mov   BL,Col                { BL = Column                        }
  50.                                    { Set up ES:DI for LDS               }
  51.        xor   AX,AX                 { AX = 0                             }
  52.        mov   CL,AL                 { CL = 0                             }
  53.        mov   BH,AL                 { BH = 0                             }
  54.        dec   CH                    { convert to DOS 0..24 coords        }
  55.        shr   CX,1                  { CX = Row * 128                     }
  56.        mov   DI,CX                 { Store in DI                        }
  57.        shr   DI,1                  { DI = Row * 64                      }
  58.        shr   DI,1                  { DI = Row * 32                      }
  59.        add   DI,CX                 { DI = (Row * 160)                   }
  60.        dec   BX                    { convert to DOS 0..79 coords        }
  61.        shl   BX,1                  { Account for attribute bytes        }
  62.        add   DI,BX                 { DI = (Row * 160) + (Col * 2)       }
  63.        add   DI,0                  { Add base address                   }
  64.        mov   ES,BaseOfScreen       { ES:DI points to first Row,Col Attr }
  65.        mov   CL,CheckSnow          { Need to wait?                      }
  66.        lds   SI,Str                { DS:SI points to Str[0]             }
  67.        cld                         { Set direction to forward           }
  68.        lodsb                       { AX = Length(St); DS:SI -> Str[1]   }
  69.        xchg  AX,CX                 { CX = Length; AL = CheckSnow        }
  70.        jcxz  @Exit                 { exit if string empty               }
  71.        mov   AH,Attr               { AH = display attribute             }
  72.        rcr   AL,1                  { If CheckSnow is False...           }
  73.        jnc   @NoWait               {  use "NoWait" routine              }
  74.        mov   DX,CGAInfo            { Point DX to CGA status port        }
  75.   @GetNext:
  76.        lodsb                       { Load next character into AL        }
  77.        mov   BX,AX                 { Store video word in BX             }
  78.        cli                         { hold interrupts                    }
  79.   @WaitNoH:
  80.        in    AL,DX                 { get retrace situation              }
  81.        test  AL,8                  { retracing?                         }
  82.        jnz   @Go                   { If so, go                          }
  83.        rcr   AL,1                  { Else, wait for end of              }
  84.        jc    @WaitNoH              {  horizontal retrace                }
  85.   @WaitH:
  86.        in    AL,DX                 { get retrace situation              }
  87.        rcr   AL,1                  { Wait for horizontal                }
  88.        jnc   @WaitH                {  retrace                           }
  89.   @Go:
  90.        mov   AX,BX                 { Move word back to AX...            }
  91.        stosw                       {  and then to screen                }
  92.        sti                         { OK to interrupt now                }
  93.        loop  @GetNext              { Get next character                 }
  94.        jmp   @Exit                 { wind up                            }
  95.   @NoWait:
  96.        lodsb                       { Load next character into AL        }
  97.        stosw                       { Move video word into place         }
  98.        loop  @NoWait               { Get next character                 }
  99.   @Exit:
  100.        pop   DS                    { clean up and go home               }
  101.  end {FastWrite};
  102.  
  103. {
  104. From: JENS LARSSON
  105. Subj: fast write
  106. }
  107.  
  108.       Procedure WriteXY(x, y : Word; MsgText : String; ColorAttr : Byte);
  109. Assembler;
  110.        Asm
  111.         dec   x
  112.         dec   y
  113.  
  114.         mov   ax,y
  115.         mov   cl,5
  116.         shl   ax,cl
  117.         mov   di,ax
  118.         mov   cl,2
  119.         shl   ax,cl
  120.         add   di,ax
  121.         shl   x,1
  122.         add   di,x
  123.  
  124.         mov   ax,0b800h     { 0b000h for mono }
  125.         mov   es,ax
  126.         xor   ch,ch
  127.         push  ds
  128.         lds   si,MsgText
  129.         lodsb
  130.         mov   cl,al
  131.         mov   ah,ColorAttr
  132.         jcxz  @@End
  133. @@L1:
  134.         lodsb
  135.         stosw
  136.         loop  @@L1
  137. @@End:
  138.         pop   ds
  139.        End;
  140.  
  141.